I am learning flutter from JustAcademy, They provide very much great environment where people gather and work simultaneously. totally project based training institute.
Awesome Experience. I am a Front-end Web Designer working at Star India for 3 years now. I applied for Full-stack development and my experience has been phenomenal & they really do help with placements exceptionally. Thank you Roshan sir so much.
Java continues to be one of the most in-demand programming languages across the software industry in India in 2026. From product companies and MNCs to startups and IT service firms, Core Java proficiency is assessed in almost every technical interview for developer, analyst, and engineering roles. A fresher who cannot clearly explain OOPs principles, collections, exception handling, and core language concepts under interview pressure is at a significant disadvantage regardless of their academic performance.
This blog covers the most important core java interview questions with answers, organized from basic to advanced, with clear explanations that you can study, practice, and reference before your next interview. Whether you are preparing for your first campus placement or applying for a junior developer role, this guide provides complete coverage of the concepts interviewers consistently assess. Each question is numbered so you can track your preparation and revisit specific topics efficiently.
Despite the rise of newer languages and frameworks, Core Java remains the backbone of enterprise software development across banking, insurance, e-commerce, telecommunications, and IT services in India and globally. Spring Boot, Hibernate, and Android all build on Core Java fundamentals, which means companies hiring for any Java-related role first verify that candidates have a strong grasp of the core language before assessing framework knowledge. For freshers, this means Core Java interview preparation is not optional but essential.
Core Java interview rounds for fresher roles typically cover five areas. First, OOPs principles including encapsulation, inheritance, polymorphism, and abstraction. Second, Java language fundamentals including data types, keywords, and memory management. Third, exception handling including checked and unchecked exceptions and the use of try, catch, finally, throw, and throws. Fourth, collections framework including List, Set, Map, and Queue interfaces and their common implementations. Fifth, multithreading basics including thread creation, lifecycle, and synchronization. Interviewers assess both theoretical understanding and the ability to explain concepts clearly with examples.
Java is a high-level, object-oriented programming language developed by Sun Microsystems in 1995 and currently maintained by Oracle. It is platform independent because Java source code is compiled into bytecode rather than directly into machine code. This bytecode is then executed by the Java Virtual Machine, which is available for every major operating system. The principle behind this is Write Once Run Anywhere, meaning code written and compiled on one platform can run on any other platform that has a JVM installed without requiring recompilation.
| Term | Full Form | Purpose |
|---|---|---|
| JVM | Java Virtual Machine | Executes Java bytecode on the host operating system |
| JRE | Java Runtime Environment | Provides libraries and JVM needed to run Java programs |
| JDK | Java Development Kit | Complete development toolkit including JRE, compiler, and debugging tools |
JDK is used by developers to write and compile Java programs. JRE is used by end users to run Java applications. JVM is the engine that actually executes the compiled bytecode. This distinction is one of the most commonly asked core java interview questions for freshers.
The four pillars of Object-Oriented Programming are the foundation of almost every OOPs interview question round and must be understood clearly with examples.
Encapsulation is the practice of wrapping data and the methods that operate on that data into a single unit called a class, and restricting direct access to internal state through access modifiers. It protects the integrity of an object's data and allows controlled access through getter and setter methods.
Inheritance is the mechanism by which one class acquires the properties and behaviour of another class. It promotes code reusability and establishes a parent-child relationship between classes. Java supports single, multilevel, and hierarchical inheritance through the extends keyword.
Polymorphism is the ability of an object to take many forms. In Java it is achieved through method overloading at compile time, where multiple methods share the same name but have different parameters, and through method overriding at runtime, where a subclass provides its own implementation of a method defined in the parent class.
Abstraction is the process of hiding implementation details and exposing only the essential features of an object to the outside world. In Java it is achieved using abstract classes and interfaces.
| Feature | Abstract Class | Interface |
|---|---|---|
| Methods | Can have abstract and concrete methods | All methods abstract by default before Java 8; default and static methods allowed from Java 8 |
| Variables | Can have instance variables | Variables are public, static, and final by default |
| Inheritance | A class can extend only one abstract class | A class can implement multiple interfaces |
| Constructor | Can have constructors | Cannot have constructors |
| Use Case | Used when classes share common state and behaviour | Used to define a contract for unrelated classes |
Method overloading occurs when two or more methods in the same class have the same name but different parameter lists. The correct method is determined at compile time based on the argument types and count. It is an example of compile-time polymorphism.
Method overriding occurs when a subclass provides its own specific implementation for a method that is already defined in its parent class. The method signature must be identical. The correct method is determined at runtime based on the actual object type. It is an example of runtime polymorphism.
A constructor is a special block of code that is automatically called when an object of a class is created. It has the same name as the class and does not have a return type. Java supports three types of constructors.
A default constructor takes no arguments and is automatically provided by Java if no constructor is explicitly defined in the class. A parameterized constructor accepts arguments and uses them to initialize object properties with specific values at the time of creation. A copy constructor creates a new object as a copy of an existing object by accepting an object of the same class as a parameter.
The == operator checks reference equality. It compares whether two reference variables point to the same memory location. The .equals() method checks value equality. It compares the actual content or state of two objects.
For String objects, two variables holding the same text created using the new keyword will return false with == because they are stored at different memory locations, but will return true with .equals() because their content is identical. String literals from the string pool may return true with == because Java reuses the same object, but relying on == for content comparison is incorrect practice.
Exception handling is the mechanism by which Java manages runtime errors so that normal program flow can be maintained or the error can be reported gracefully. Java uses five keywords for this purpose.
The try block contains code that might throw an exception. The catch block handles a specific type of exception if it is thrown. The finally block always executes after the try-catch regardless of whether an exception occurred, typically used for cleanup. The throw keyword is used to explicitly throw an exception from within code. The throws keyword is used in a method signature to declare that the method may throw certain exceptions.
Checked exceptions are exceptions that are checked at compile time. The compiler forces the programmer to either handle them with a try-catch block or declare them with the throws keyword. Examples include IOException, SQLException, and FileNotFoundException.
Unchecked exceptions are subclasses of RuntimeException and are not checked at compile time. They typically indicate programming errors such as null references, array index violations, or invalid type casts. Examples include NullPointerException, ArrayIndexOutOfBoundsException, and ClassCastException.
| Keyword | Description |
|---|---|
| final | Modifier used to declare constants, prevent method overriding, and prevent class inheritance |
| finally | Block that always executes after a try-catch, used for cleanup operations like closing connections |
| finalize | Method called by the garbage collector just before an object is destroyed, used for resource cleanup |
The Java Collections Framework is a unified architecture for representing and manipulating groups of objects. It provides a set of interfaces and classes that implement commonly used data structures. The main interfaces are List, which is an ordered collection allowing duplicates; Set, which is an unordered collection not allowing duplicates; Map, which stores key-value pairs; and Queue, which follows first-in-first-out order. Common implementations include ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap, and PriorityQueue.
| Feature | ArrayList | LinkedList |
|---|---|---|
| Internal Structure | Dynamic array | Doubly linked list |
| Random Access | Fast, O(1) using index | Slow, O(n) requires traversal |
| Insertion and Deletion | Slow in the middle due to shifting | Fast in the middle, only pointer updates needed |
| Memory Usage | Less memory per element | More memory due to storing node pointers |
| Best Use Case | Frequent read operations | Frequent insert and delete operations |
HashMap is not synchronized and is not thread-safe, making it faster in single-threaded environments. It allows one null key and multiple null values. HashTable is synchronized and thread-safe, making it suitable for multi-threaded use but slower. It does not allow null keys or null values. In modern Java development, ConcurrentHashMap is preferred over HashTable for thread-safe map operations because it offers better performance through segment-level locking.
HashSet stores elements using a hash table and does not maintain any order. It offers O(1) average time complexity for basic operations. TreeSet stores elements in a sorted order according to their natural ordering or a provided comparator, using a red-black tree internally. Its basic operations run in O(log n) time. HashSet is preferred when ordering does not matter and speed is the priority. TreeSet is preferred when a sorted collection is required.
Multithreading is the ability of a Java program to execute multiple threads simultaneously, allowing multiple tasks to run in parallel within the same process. It improves CPU utilization and application responsiveness.
A thread in Java can be created in two ways. The first is by extending the Thread class and overriding its run method. The second is by implementing the Runnable interface and passing the Runnable object to a Thread instance. Implementing Runnable is generally preferred because Java supports only single inheritance, and implementing an interface keeps the class free to extend another class if needed.
A thread in Java passes through five states during its lifetime. New is the state when a thread object is created but the start method has not yet been called. Runnable is the state after start is called and the thread is ready to run or is already running. Blocked or Waiting is the state when a thread is paused, waiting for a resource, lock, or notification. Timed Waiting is a waiting state with a specified timeout period, such as when Thread.sleep is called. Terminated is the final state when the thread has completed execution or has been stopped.
Synchronization is the process of controlling access to shared resources by multiple threads to prevent data inconsistency. When multiple threads access and modify shared data simultaneously, race conditions can occur where the final state of the data depends on the unpredictable order of thread execution. The synchronized keyword in Java can be applied to methods or blocks of code to ensure that only one thread can execute the synchronized section at a time. While synchronization prevents data corruption, it introduces overhead and can cause performance bottlenecks if overused.
| Feature | String | StringBuilder | StringBuffer |
|---|---|---|---|
| Mutability | Immutable | Mutable | Mutable |
| Thread Safety | Thread safe due to immutability | Not thread safe | Thread safe, synchronized |
| Performance | Slowest for repeated modifications | Fastest | Slower than StringBuilder |
| Best Use Case | Fixed text, constant values | Single-threaded string manipulation | Multi-threaded string manipulation |
The static keyword in Java indicates that a member belongs to the class itself rather than to any specific instance of the class. A static variable is shared across all instances and is initialized only once when the class is loaded. A static method can be called without creating an object of the class and can only directly access other static members. A static block is executed once when the class is first loaded into memory and is often used for complex static initialization. Static inner classes can be instantiated without an instance of the outer class.
The this keyword refers to the current instance of the class. It is used to distinguish between instance variables and local variables that share the same name, to call another constructor within the same class using this(), and to pass the current object as a method argument.
The super keyword refers to the immediate parent class. It is used to call the parent class constructor using super(), to access parent class methods that have been overridden in the child class, and to access parent class fields that are hidden by fields in the child class.
The throw keyword is used within a method body to explicitly throw an exception object. Only one exception can be thrown at a time with throw. The throws keyword is used in a method signature to declare that the method may throw one or more exceptions, informing the caller that they must handle these exceptions. Multiple exception types can be listed after throws separated by commas.
Garbage collection in Java is the automatic process of reclaiming memory occupied by objects that are no longer reachable or referenced by any part of the program. The JVM runs the garbage collector periodically in the background. The main garbage collection algorithm divides heap memory into young generation, old generation, and permanent generation spaces. Short-lived objects are allocated in the young generation and collected frequently in minor GC cycles. Objects that survive multiple minor GC cycles are promoted to the old generation and collected less frequently in major GC cycles.
From a design perspective, an abstract class is used when you want to provide a common base with some shared implementation that subclasses can build upon. It represents an is-a relationship where all subclasses are a type of the parent. An interface is used when you want to define a contract that any class can implement regardless of its position in the inheritance hierarchy. It represents a can-do relationship. For example, a Bird abstract class might define flying behaviour for birds, but a Flyable interface can be implemented by both birds and aircraft because they share a capability rather than a common type.
Wrapper classes provide an object representation for each of the eight primitive data types in Java. The wrapper classes are Integer for int, Double for double, Float for float, Long for long, Short for short, Byte for byte, Character for char, and Boolean for boolean. They are needed when working with collections that can only store objects, when using generics, when converting between data types, and when using utility methods for parsing and formatting. Java automatically converts between primitives and their wrapper classes through a mechanism called autoboxing and unboxing.
Autoboxing is the automatic conversion of a primitive type to its corresponding wrapper class object when needed, such as when adding an int to an ArrayList. Unboxing is the reverse process, automatically converting a wrapper class object back to its primitive type when needed, such as when performing arithmetic on an Integer variable. Autoboxing and unboxing make code cleaner by eliminating the need for explicit conversion calls, but they introduce a small performance overhead because objects are being created or unwrapped behind the scenes.
A functional interface is an interface that contains exactly one abstract method. It can have any number of default or static methods but must have only one abstract method. Functional interfaces are the foundation of lambda expressions introduced in Java 8. Common built-in functional interfaces include Runnable, Callable, Comparator, and the interfaces in the java.util.function package such as Predicate, Function, Consumer, and Supplier. The @FunctionalInterface annotation can be used to indicate that an interface is intended to be functional, causing the compiler to enforce the single abstract method constraint.
Lambda expressions are a feature introduced in Java 8 that provide a concise way to represent an implementation of a functional interface as an anonymous function. Instead of writing a full anonymous inner class with boilerplate code, a lambda expression can express the same behaviour in a single line. Lambda expressions make code more readable, reduce verbosity, and enable functional programming patterns in Java. They are commonly used with the Streams API, Collections sorting, and event handling.
The Stream API introduced in Java 8 provides a functional approach to processing collections of data. A stream is a sequence of elements that supports sequential and parallel aggregate operations. Streams are not data structures and do not store data. They process data from a source such as a collection, array, or IO channel through a pipeline of operations. Operations are divided into intermediate operations like filter, map, and sorted which return a new stream, and terminal operations like collect, forEach, count, and reduce which produce a result or side effect. Streams enable clean, declarative data processing code that replaces traditional for-loop patterns.
Iterator can traverse any collection in the forward direction only. It supports three operations: hasNext to check if more elements exist, next to retrieve the next element, and remove to remove the current element from the collection. ListIterator is a more powerful version that can only be used with List implementations. It can traverse in both forward and backward directions using hasNext, next, hasPrevious, and previous. It also supports add, set, and remove operations, and can return the index of the current element. For most traversal tasks, Iterator is sufficient, but ListIterator is needed when bidirectional traversal or element replacement is required.
Serialization is the process of converting an object into a byte stream so that it can be persisted to a file, sent over a network, or stored in a database. Deserialization is the reverse process of reconstructing the object from the byte stream. For a class to be serializable, it must implement the java.io.Serializable interface, which is a marker interface with no methods. Fields marked with the transient keyword are excluded from serialization and will be set to their default values upon deserialization. Serialization is widely used in distributed systems, caching, and session management.
Reading interview questions without first building a solid understanding of the underlying concepts leads to surface-level preparation that breaks down under follow-up questions. Before working through this list, ensure you have a clear conceptual understanding of OOPs, Java memory model, the collections hierarchy, and exception handling mechanics. Interviewers at most companies will probe beyond your initial answer to test whether you genuinely understand what you have said or have simply memorized it.
Core Java interviews for fresher roles almost always include a coding component alongside conceptual questions. Practising on platforms like LeetCode and HackerRank builds the ability to translate knowledge into working code under pressure. Focus on problems that involve arrays, strings, collections, and basic OOPs design patterns. Being able to write clean, compilable code during an interview demonstrates a level of understanding that verbal answers alone cannot.
Several core java interview questions are designed specifically to catch candidates who have memorized definitions without genuine understanding. Common traps include asking the difference between == and .equals() with a specific example to see if you understand reference versus value comparison, asking about method overriding rules to check if you know about covariant return types and access modifier constraints, and presenting broken code and asking why it does not compile or run correctly. Practicing applied questions in addition to definitional ones is essential preparation.
Self-study through tutorials and blog posts introduces you to Java concepts but rarely builds the systematic understanding and hands-on coding confidence needed to perform well under interview pressure. Structured training programs that use real project work, include live doubt resolution from industry experts, and assess your ability to apply concepts to programming problems produce significantly better interview outcomes for the majority of freshers.
The best interactive Core Java training programs and the best Core Java courses in Mumbai include practical coding assignments, mock interview preparation, and instructor feedback that prepares you specifically for the types of questions covered in this blog and beyond.
JustAcademy's Core Java Training in Mumbai covers every concept assessed in fresher developer interviews within a structured curriculum that progresses from language fundamentals to OOPs design, collections, exception handling, multithreading, and Java 8 features. It is one of the best Core Java courses in Mumbai for freshers who want to build complete interview readiness with hands-on project experience and placement support. For learners anywhere in India or globally, the Core Java Training Online delivers the same live interactive training with real-world coding assignments and career guidance from any location.
Building proficiency across the full Java development stack makes you a stronger candidate in every interview round. Explore these programs at JustAcademy:
Core java interview questions test far more than memorized definitions. They assess your ability to explain OOPs principles clearly, apply collection classes to real scenarios, write exception handling code correctly, and understand how Java manages memory and threads at a conceptual level. The thirty questions covered in this blog span the full range of what interviewers assess for fresher Java developer roles in India in 2026.
Preparation that combines thorough knowledge of these questions with consistent coding practice on real problems will position you strongly for any Core Java interview round. The fastest and most reliable path to that preparation is through a structured training program that covers Core Java within the full context of a developer skill set, includes live instruction and real project work, and prepares you specifically for the interview formats you will face.
For learners in Maharashtra, the Core Java Training in Mumbai at JustAcademy is one of the best Core Java courses in Mumbai available today, combining foundational Java, OOPs, collections, multithreading, and placement support in one job-oriented program. For learners anywhere in India or globally, the Core Java Training Online delivers the same live interactive training experience with the flexibility to learn from wherever you are.
Register for a Free Demo to experience the curriculum and speak with an advisor about your interview preparation goals, or Download the Brochure to review full course details, batch schedules, and fees before you decide.
Selenium WebDriver Interview Questions and Answers for Freshers and Experienced Testers in 2026
UI UX Interview Questions and Answers for Freshers and Beginners Covering Design Thinking, Figma, Wireframing, and UX Research in 2026
Figma Interview Questions and Answers for UI UX Designers, Freshers, and Experienced Designers in 2026
SQL, ORM, and Database Interview Questions and Answers for Python Backend Developers and Freshers in
OOP Concepts, Python Classes Interview Questions and Answers for Beginners and Freshers in 2026
REST API, FastAPI, and Django REST Framework Interview Questions and Answers for Python Freshers and Developers in 2026
Flask API, Python Backend Interview Questions and Answers for Beginners and Freshers in 2026
Django Interview, Python Backend Questions and Answers for Freshers and Beginners in 2026
Python DSA, Coding Interview Questions and Answers for Freshers and Beginners in 2026
Version Control, GitHub Interview Questions and Answers for Python Developers and Freshers in 2026
